home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 September (IDG) / Sep99.iso / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / latex Mode / latexMacros.tcl < prev    next >
Encoding:
Text File  |  1999-04-28  |  41.8 KB  |  1,547 lines  |  [TEXT/ALFA]
  1. #############################################################################
  2. #############################################################################
  3. #
  4. # latexMacros.tcl (called from latex.tcl)
  5. #
  6. #############################################################################
  7. #
  8. # Author:  Tom Scavo <trscavo@syr.edu>, Vince Darley <darley@fas.harvard.edu>
  9. #
  10. #############################################################################
  11. #############################################################################
  12. proc latexMacros.tcl {} {}
  13. #############################################################################
  14. # 
  15. # Basic Commands
  16. #
  17. #############################################################################
  18. # ◊◊◊◊ label returners ◊◊◊◊ #
  19. proc TeX::labelDelim {} {
  20.     global TeXmodeVars
  21.     return $TeXmodeVars(standardTeXLabelDelimiter)
  22. }
  23. proc TeX::label {type} {
  24.     global TeXmodeVars
  25.     return "\\label\{${type}$TeXmodeVars(standardTeXLabelDelimiter)••\}"
  26. }
  27.  
  28. #--------------------------------------------------------------------------
  29. # ◊◊◊◊ Utilities: ◊◊◊◊
  30. #--------------------------------------------------------------------------
  31. # A keyboard-bound method of accessing menu commands.  Takes a list of 
  32. # menu items (i.e., the tail of a 'menu' command), the menu name (the 
  33. # argument of the '-n' switch) , and the name of a menu filter (the 
  34. # argument of the '-p' switch) as input, and displays these items in a 
  35. # list box.  If the chosen item is a menu command (as opposed to a 
  36. # submenu), it is passed to the menu filter; otherwise, 'chooseCommand' 
  37. # recursively calls itself until a menu command is chosen or the cancel 
  38. # button is pressed.
  39. #
  40. proc chooseCommand {menuItems {menuName ""} {menuFilterProc ""} {level 1}} {
  41.     watchCursor
  42.     if { $menuItems == "" } { return }
  43.     # Preprocess the list of menu items:
  44.     foreach    item $menuItems {
  45.         regsub -all {[<!/].} $item {} item
  46.         regsub -all {…}    $item {} item
  47.         lappend    menOut $item
  48.         if { [string match "menu*" $item] } {
  49.             if { [set ind [lsearch $item {-n}]] >= 0 } {
  50.                 lappend    top "[lindex $item [incr    ind]]:"
  51.             }
  52.         } elseif { ![string match "(*" $item] } {
  53.             lappend    top $item
  54.         }
  55.     }
  56.     # Present the menu items to the user:
  57.     set res    [listpick -p "Choose menu command (level $level):" $top]
  58.     # Either execute a command or recurse on a submenu:
  59.     if { [lsearch $menOut $res] >= 0 } {
  60.         # Execute the command via the menu filter, if necessary:
  61.         if { $menuFilterProc == "" } {
  62.             $res
  63.         } else {
  64.             $menuFilterProc $menuName $res
  65.         }
  66.     } else {
  67.         set res [string trimright $res {:}]
  68.         foreach    item $menOut {
  69.             if { [lsearch $item $res] >= 0 } {
  70.                 set menuItems [lindex $item end]
  71.                 # Determine the name of this submenu:
  72.                 if { [set ind [lsearch $item {-n}]] >= 0 } {
  73.                     set menuName [lindex $item [incr ind]]
  74.                 } else {
  75.                     set menuName ""
  76.                 }
  77.                 # Determine the name of the menu filter for this submenu:
  78.                 if { [set ind [lsearch $item {-p}]] >= 0 } {
  79.                     set menuFilterProc [lindex $item [incr ind]]
  80.                 } else {
  81.                     set menuFilterProc ""
  82.                 }
  83.                 return [chooseCommand $menuItems $menuName $menuFilterProc [incr level]]
  84.             }
  85.         }
  86.     }
  87. }
  88. # A keyboard-bound method of inserting environments.
  89. #
  90. proc chooseEnvironment {} {
  91.     set env [getEnvironment]
  92.     if { [catch {eval $env}] } {
  93.         doWrapEnvironment $env
  94.     }
  95. }
  96. proc getEnvironment {} {
  97.     if { [catch {prompt "Choose environment:" "abstract" "" \
  98.                  "abstract" \
  99.                  "array" \
  100.                  "center" \
  101.                  "description" \
  102.                  "displaymath" \
  103.                  "document" \
  104.                  "enumerate" \
  105.                  "eqnarray" \
  106.                  "eqnarray*" \
  107.                  "equation" \
  108.                  "figure" \
  109.                  "filecontents" \
  110.                  "flushleft" \
  111.                  "flushright" \
  112.                  "itemize" \
  113.                  "math" \
  114.                  "minipage" \
  115.                  "note" \
  116.                  "overlay" \
  117.                  "quotation" \
  118.                  "quote" \
  119.                  "slide" \
  120.                  "table" \
  121.                  "tabular" \
  122.                  "thebibliography" \
  123.                  "titlepage" \
  124.                  "verbatim" \
  125.                  "verse" \
  126.                 } env] } {
  127.         set env ""
  128.     }
  129.     return $env
  130. }
  131.  
  132. #############################################################################
  133. # 
  134. # Paragraph Mode Macros
  135. #
  136. #############################################################################
  137. #--------------------------------------------------------------------------
  138. # ◊◊◊◊ Documents: ◊◊◊◊
  139. #--------------------------------------------------------------------------
  140. proc newLaTeXDocument {} {
  141.     catch {prompt "Choose a documentclass:" "article" "" "article" \
  142.             "report" "book" "letter" "slides"} documentType
  143.     if {$documentType != "cancel"} {
  144.         new -m TeX
  145.         if { [catch {${documentType}Documentclass}] } {
  146.             wrapDocument "$documentType" 
  147.         }
  148.         while { [options] } {}
  149.         message "enter option (or leave blank)"
  150.     }
  151. }
  152. proc letterDocumentclass {} {
  153.     set    preamble "\r\\address\{%\r"
  154.     append preamble "    ••    \\\\    % insert your name here\r"
  155.     append preamble "    ••    \\\\    % insert your address here\r"
  156.     append preamble "    ••    \\\\    % insert more address here\r"
  157.     append preamble "    ••          % insert city-state-zip here\r"
  158.     append preamble "\}\r\r"
  159.     append preamble "\\date\{••\}  % optional\r"
  160.     append preamble "\\signature\{••\}\r\r"
  161.     set    body     "\r\\begin\{letter\}\{%\r"
  162.     append body     "    ••    \\\\    % insert addressee's name here\r"
  163.     append body     "    ••    \\\\    % insert addressee's address here\r"
  164.     append body     "    ••    \\\\    % insert more address here\r"
  165.     append body     "    ••          % insert addressee's city-state-zip here\r"
  166.     append body     "\}\r\r"
  167.     append body     "\\opening\{Dear ••,\}\r\r"
  168.     if {[isEmptyFile]} {
  169.         append body "% BODY OF LETTER\r"
  170.         append body "••\r\r"
  171.     } else {
  172.         if {[isSelectionAll]} {
  173.             set text [getSelect]
  174. #             deleteText [minPos] [maxPos]
  175.             append body "$text\r"
  176.         } else {
  177.             alertnote "nonempty file:  delete text or \'Select All\'\
  178.                 from the Edit menu"
  179.             return
  180.         }
  181.     }
  182.     append body "\\closing\{Sincerely,\}\r\r"
  183.     append body "\\encl\{••\}\r"
  184.     append body "\\cc\{••\}\r\r"
  185.     append body "\\end\{letter\}\r\r"
  186.     insertDocument "letter" $preamble $body
  187.     message "enter option (or leave blank)"
  188. }
  189. proc articleDocumentclass {} {
  190.     if { [wrapDocument "article"] } {
  191.         message "enter option (or leave blank)"
  192.     }
  193. }
  194. proc reportDocumentclass {} {
  195.     if { [wrapDocument "report"] } {
  196.         message "enter option (or leave blank)"
  197.     }
  198. }
  199. proc bookDocumentclass {} {
  200.     if { [wrapDocument "book"] } {
  201.         message "enter option (or leave blank)"
  202.     }
  203. }
  204. proc slidesDocumentclass {} {
  205.     if { [wrapDocument "slides"] } {
  206.         message "enter option (or leave blank)"
  207.     }
  208. }
  209. proc otherDocumentclass {} {
  210.     catch {prompt "What documentclass?" "article"} documentType
  211.     if {$documentType != "cancel"} {
  212.         if { [wrapDocument "$documentType"] } {
  213.             message "enter option (or leave blank)"
  214.         }
  215.     }
  216. }
  217. # If an option is inserted, return true; otherwise, return false.
  218. proc options {} {
  219.     set option [getOption]
  220.     if {$option != ""} {
  221.         insertOption $option
  222.         return 1
  223.     }
  224.     return 0
  225. }
  226. proc getOption {} {
  227.     catch {prompt "Choose an option:" "11pt" "" "10pt" "11pt" "12pt" "(-" \
  228.             "letterpaper" "legalpaper" "executivepaper" "a4paper" "a5paper" \
  229.             "b5paper" "(-" "landscape" "(-" "final" "draft" "(-" \
  230.             "oneside" "twoside" "(-" "openright" "openany" "(-" \
  231.             "onecolumn" "twocolumn" "(-" "notitlepage" "titlepage" \
  232.                   "openbib" "(-" "leqno" "(-" "fleqn"} optionName
  233.     if {$optionName != "cancel"} {
  234.         return $optionName
  235.     } else {
  236.         return ""
  237.     }
  238. }
  239. proc insertOption {option} {
  240.     global TeXmodeVars
  241.     set searchString {\\documentclass}
  242.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  243.     if {[llength $searchResult] == 0} {
  244.         if { $TeXmodeVars(searchNoisily) } {beep}
  245.         message "can\'t find \\documentclass"
  246.     } else {
  247.         set nextCharPos [lindex $searchResult 1]
  248.         goto $nextCharPos
  249.         set nextChar [lookAt $nextCharPos]
  250.         if {$nextChar == "\["} {
  251.             forwardChar
  252.             insertText $option
  253.             if {[lookAt [getPos]] != "\]"} {
  254.                 insertText ","
  255.             }
  256.         } elseif {$nextChar == "\{"} {
  257.             insertText "\[$option\]"
  258.         } else {
  259.             alertnote "unrecognizable \\documentclass statement"
  260.         }
  261.     }
  262. }
  263. proc insertPackage {package} {
  264.     global TeXmodeVars
  265.     # Check to see if $package is already loaded:
  266.     if { $package != "" } {
  267.         append searchString {^[^%]*\\usepackage\{.*} $package {.*\}}
  268.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  269.         if {[llength $searchResult] != 0} {
  270.             if { $TeXmodeVars(searchNoisily) } {beep}
  271.             message "$package package already loaded"
  272.             return
  273.         }
  274.     }
  275.     # Newlines are allowed in the arguments of \documentclass:
  276.     set searchString {\\documentclass(\[[^][]*\])?{[^{}]*}}
  277.     # Search for \documentclass command:
  278.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  279.     if {[llength $searchResult] == 0} {
  280.         if { $TeXmodeVars(searchNoisily) } {beep}
  281.         message "can't find \\documentclass"
  282.     } else {
  283.         pushPosition
  284.         goto [lindex $searchResult 1]
  285.         set txt "\r\\usepackage\{$package\}"
  286.         insertText $txt
  287.         backwardChar
  288.         message "Press <Ctl .> to return to previous position"
  289.     }
  290. }
  291. proc filecontents {} {
  292.     global searchNoisily
  293.     set searchString {\\documentclass}
  294.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  295.     if {[llength $searchResult] == 0} {
  296.         if {$searchNoisily} {beep}
  297.         message "can\'t find \\documentclass"
  298.         return
  299.     } else {
  300.         set prompt "File to be included:"
  301.         if {[catch {getfile $prompt} path]} {
  302.             return
  303.         } else {
  304.             replaceText [minPos] [minPos] [buildFilecontents $path]
  305.             goto [minPos]
  306.             message "file included"
  307.         }
  308.     }
  309. }
  310. proc filecontentsAll {} {
  311.     global searchNoisily
  312.     watchCursor
  313.     message "locating all input files…"
  314.     set currentWin [win::Current]
  315.     # Is the current window part of TeX fileset?
  316.     set fset [isWindowInFileset $currentWin "tex"]
  317.     if { $fset == "" } {
  318.         set searchString {\\documentclass}
  319.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  320.         if {[llength $searchResult] == 0} {
  321.             if {$searchNoisily} {beep}
  322.             message "can\'t find \\documentclass"
  323.             return
  324.         } else {
  325.             set text [getText [minPos] [maxPos]]
  326.         }
  327.     } else {
  328.         # Will not handle a base file that is open and dirty:
  329.         set text [buildFilecontents [texFilesetBaseName $fset]]
  330.     }
  331.     set currentDir [file dirname $currentWin]
  332.     set newText [texResolveAll $text $currentDir]
  333.     if { [string length $text] == [string length $newText] } {
  334.         beep
  335.         message "no files to include"
  336.     } else {
  337.         replaceText [minPos] [maxPos] $newText
  338.         goto [minPos]
  339.         message "all files included"
  340.     }
  341. }
  342. # Takes a LaTeX document string and a path as input, and returns
  343. # a modified document string with all filecontents environments
  344. # prepended.
  345. proc texResolveAll {latexDoc currentDir} {
  346.     global TeXmodeVars
  347.     set pairs [list \
  348.                 {{\\documentclass} {.cls}} {{\\LoadClass} {.cls}} \
  349.                 {{\\include} {.tex}} \
  350.                 {{\\usepackage} {.sty}} {{\\RequirePackage} {.sty}} \
  351.                 {{\\input} {}} \
  352.                 {{\\bibliography} {.bib}} {{\\bibliographystyle} {.bst}} \
  353.               ]
  354.     foreach macro $TeXmodeVars(boxMacroNames) {
  355.         regsub {\*} $macro {\\*} macro
  356.         lappend pairs [list \\\\$macro {}]
  357.     }
  358.     foreach pair $pairs {
  359.         set cmd [lindex $pair 0]
  360.         set ext [lindex $pair 1]
  361.         set searchString $cmd
  362.         append searchString {(\[[^][]*\])?{([^{}]*)}}
  363.         set searchText $latexDoc
  364.         while { [regexp -indices -- $searchString $searchText mtch dummy theArgs] } {
  365.             set begPos [lindex $theArgs 0]
  366.             set endPos [lindex $theArgs 1]
  367.             set args [string range $searchText $begPos $endPos]
  368.             foreach arg [split $args ,] {
  369.                 if { $cmd == {\\input} && ![string length [file extension $arg]] } {
  370.                     set ext {.tex}
  371.                 }
  372.                 set files [glob -nocomplain [file join $currentDir $arg*]]
  373.                 set filename [file join $currentDir $arg$ext]
  374.                 if { [lsearch -exact $files $filename] > -1 } {
  375.                     set tempDoc $latexDoc
  376.                     set latexDoc [buildFilecontents $filename]
  377.                     append latexDoc $tempDoc
  378.                 }
  379.             }
  380.             set searchText [string range $searchText [expr $endPos + 2] end]
  381.         }
  382.     }
  383.     return $latexDoc
  384. }
  385. # Takes a filename as input and returns a filecontents environment 
  386. # based on the contents of that file.  If a second argument is given,
  387. # use that as the argument of the filecontents environment instead
  388. # of the original filename.
  389. proc buildFilecontents {filename {newFilename {}}} {
  390.     set text [readFile $filename]
  391.     # Fix end-of-line characters:
  392.     regsub -all "\xa" $text "\xd" text
  393.     set envName "filecontents"
  394.     if { $newFilename == {} } {
  395.         set envArg "{[file tail $filename]}"
  396.     } else {
  397.         set envArg "{$newFilename}"
  398.     }
  399.     return [buildEnvironment $envName $envArg "$text\r" "\r\r"]
  400. }
  401. #--------------------------------------------------------------------------
  402. # ◊◊◊◊ Page Layout: ◊◊◊◊
  403. #--------------------------------------------------------------------------
  404. proc maketitle {} {
  405.     global searchNoisily
  406.     set searchString {\\document(class|style)(\[.*\])?\{.*\}}
  407.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  408.     if {[llength $searchResult] == 0} {
  409.         if {$searchNoisily} {beep}
  410.         message "can\'t find \\documentclass or \\documentstyle"
  411.     } else {
  412.         set searchPos [lindex $searchResult 1]
  413.         set searchString {\\begin\{document\}}
  414.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString $searchPos]
  415.         if {[llength $searchResult] == 0} {
  416.             if {$searchNoisily} {beep}
  417.             message "can\'t find \\begin\{document\}"
  418.         } else {
  419.             goto [lindex $searchResult 1]
  420.             set currentPos [getPos]
  421.             set txt "\r\r% Definition of title page:"
  422.             append txt "\r\\title\{"
  423.             append txt "\r\t•title•\r\}"
  424.             append txt "\r\\author\{"
  425.             append txt "\r\t••\t% insert author(s) here"
  426.             append txt "\r\}"
  427.             append txt "\r\\date\{••\}\t% optional"
  428.             append txt "\r\r\\maketitle"
  429.             elec::Insertion $txt
  430.         }
  431.     }
  432. }
  433. proc abstract {} { doWrapEnvironment "abstract" }
  434. proc titlepage {} { doWrapEnvironment "titlepage" }
  435. proc getPagestyle {} {
  436.     catch {prompt "Choose a pagestyle:" "plain" "" "plain" "empty" \
  437.                   "headings" "myheadings"} pagestyleName
  438.     if {$pagestyleName != "cancel"} {
  439.         return $pagestyleName
  440.     } else {
  441.         return ""
  442.     }
  443. }
  444. proc pagestyle {} {
  445.     set pagestyleName [getPagestyle]
  446.     if {$pagestyleName != ""} {
  447.     insertObject "[openingCarriageReturn]\\pagestyle\{$pagestyleName\}[closingCarriageReturn]"
  448.     }
  449. }
  450. proc thispagestyle {} {
  451.     set pagestyleName [getPagestyle]
  452.     if {$pagestyleName != ""} {
  453.     insertObject "[openingCarriageReturn]\\thispagestyle\{$pagestyleName\}[closingCarriageReturn]"
  454.     }
  455. }
  456.  
  457. proc pagenumbering {} {
  458.     set pagenumberingStyle [getPagenumberingStyle]
  459.     if {$pagenumberingStyle != ""} {
  460.     insertObject "[openingCarriageReturn]\\pagenumbering\{$pagenumberingStyle\}[closingCarriageReturn]"
  461.     }
  462. }
  463. proc getPagenumberingStyle {} {
  464.     catch {prompt "Choose a pagenumbering style:" "arabic" "" "arabic" \
  465.       "roman" "Roman" "alph" "Alph"} pagenumberingStyle
  466.     if {$pagenumberingStyle != "cancel"} {
  467.     return $pagenumberingStyle
  468.     } else {
  469.     return ""
  470.     }
  471. }
  472. proc twocolumn {} {
  473.     insertObject "[openingCarriageReturn]\\twocolumn[closingCarriageReturn]"
  474. }
  475. proc onecolumn {} {
  476.     insertObject "[openingCarriageReturn]\\onecolumn[closingCarriageReturn]"
  477. }
  478. #--------------------------------------------------------------------------
  479. # ◊◊◊◊ Sectioning: ◊◊◊◊
  480. #--------------------------------------------------------------------------
  481. proc sectioning {item} {
  482.     append left [openingCarriageReturn] "\\${item}\{"
  483.     append right "\}"
  484.     if [regexp (part|chapter) $item] {
  485.         append right "\\thispagestyle{empty}"
  486.     }
  487.     append right "••" [closingCarriageReturn]
  488.     if [elec::Wrap $left $right] {
  489.         message "don't forget the label <Ctl Opt L>"
  490.     } else {
  491.         message "type the [string trim $item {*}] name and don't forget the label <Ctl Opt L>"
  492.     }
  493. }
  494. proc appendix {} {
  495.     insertObject "[openingCarriageReturn]\\appendix[closingCarriageReturn]"
  496. }
  497. #--------------------------------------------------------------------------
  498. # ◊◊◊◊ Text Style: ◊◊◊◊
  499. #--------------------------------------------------------------------------
  500.  
  501. proc emph {} {
  502.     if {[elec::Wrap "\\emph{" "}••"]} {
  503.         message "selected text has been emphasized"
  504.     } else {
  505.         message "enter text to be emphasized"
  506.     }
  507. }
  508. proc textup {} {
  509.     if {[elec::Wrap "\\textup{" "}••"]} {
  510.         message "selected text has upright shape"
  511.     } else {
  512.         message "enter text to have upright shape"
  513.     }
  514. }
  515. proc textit {} {
  516.     if {[elec::Wrap "\\textit{" "}••"]} {
  517.         message "selected text has italic shape"
  518.     } else {
  519.         message "enter text to have italic shape"
  520.     }
  521. }
  522. proc textsl {} {
  523.     if {[elec::Wrap "\\textsl{" "}••"]} {
  524.         message "selected text has slanted shape"
  525.     } else {
  526.         message "enter text to have slanted shape"
  527.     }
  528. }
  529. proc textsc {} {
  530.     if {[elec::Wrap "\\textsc{" "}••"]} {
  531.         message "selected text has small caps shape"
  532.     } else {
  533.         message "enter text to have small caps shape"
  534.     }
  535. }
  536. proc textmd {} {
  537.     if {[elec::Wrap "\\textmd{" "}••"]} {
  538.         message "selected text has been set in medium series"
  539.     } else {
  540.         message "enter text to be set in medium series"
  541.     }
  542. }
  543. proc textbf {} {
  544.     if {[elec::Wrap "\\textbf{" "}••"]} {
  545.         message "selected text has been set in bold series"
  546.     } else {
  547.         message "enter text to be set in bold series"
  548.     }
  549. }
  550. proc textrm {} {
  551.     if {[elec::Wrap "\\textrm{" "}••"]} {
  552.         message "selected text has been set with roman family"
  553.     } else {
  554.         message "enter text to be set using roman family"
  555.     }
  556. }
  557. proc textsf {} {
  558.     if {[elec::Wrap "\\textsf{" "}••"]} {
  559.         message "selected text has been set with sans serif family"
  560.     } else {
  561.         message "enter text to be set using sans serif family"
  562.     }
  563. }
  564. proc texttt {} {
  565.     if {[elec::Wrap "\\texttt{" "}••"]} {
  566.         message "selected text has been set with typewriter family"
  567.     } else {
  568.         message "enter text to be set using typewriter family"
  569.     }
  570. }
  571. proc textnormal {} {
  572.     if {[elec::Wrap "\\textnormal{" "}••"]} {
  573.         message "selected text has been set with normal style"
  574.     } else {
  575.         message "enter text to be set using normal style"
  576.     }
  577. }
  578.  
  579. proc em {} {
  580.     if {[elec::Wrap "{\\em " "}••"]} {
  581.         message "emphasized text set"
  582.     } else {
  583.         message "enter text to be emphasized"
  584.     }
  585. }
  586. proc upshape {} {
  587.     if {[elec::Wrap "{\\upshape " "}••"]} {
  588.         message "text set in upright shape"
  589.     } else {
  590.         message "enter text to be set in upright shape"
  591.     }
  592. }
  593. proc itshape {} {
  594.     if {[elec::Wrap "{\\itshape " "}••"]} {
  595.         message "text set in italics shape"
  596.     } else {
  597.         message "enter text to be set in italics shape"
  598.     }
  599. }
  600. proc slshape {} {
  601.     if {[elec::Wrap "{\\slshape " "}••"]} {
  602.         message "text set in slanted shape"
  603.     } else {
  604.         message "enter text to be set in slanted shape"
  605.     }
  606. }
  607. proc scshape {} {
  608.     if {[elec::Wrap "{\\scshape " "}••"]} {
  609.         message "text set in small caps shape"
  610.     } else {
  611.         message "enter text to be set in small caps shape"
  612.     }
  613. }
  614. proc mdseries {} {
  615.     if {[elec::Wrap "{\\mdseries " "}••"]} {
  616.         message "text set in medium series"
  617.     } else {
  618.         message "enter text to be set in medium series"
  619.     }
  620. }
  621. proc bfseries {} {
  622.     if {[elec::Wrap "{\\bfseries " "}••"]} {
  623.         message "text set in bold series"
  624.     } else {
  625.         message "enter text to be set in bold series"
  626.     }
  627. }
  628. proc rmfamily {} {
  629.     if {[elec::Wrap "{\\rmfamily " "}••"]} {
  630.         message "text set in roman family"
  631.     } else {
  632.         message "enter text to be set in roman family"
  633.     }
  634. }
  635. proc sffamily {} {
  636.     if {[elec::Wrap "{\\sffamily " "}••"]} {
  637.         message "text set in sans serif family"
  638.     } else {
  639.         message "enter text to be set in sans serif family"
  640.     }
  641. }
  642. proc ttfamily {} {
  643.     if {[elec::Wrap "{\\ttfamily " "}••"]} {
  644.         message "text set in typewriter family"
  645.     } else {
  646.         message "enter text to be set in typewriter family"
  647.     }
  648. }
  649. proc normalfont {} {
  650.     if {[elec::Wrap "{\\normalfont " "}••"]} {
  651.         message "text set in normal style"
  652.     } else {
  653.         message "enter text to be set in normal style"
  654.     }
  655. }
  656.  
  657. #--------------------------------------------------------------------------
  658. # ◊◊◊◊ Text Size: ◊◊◊◊
  659. #--------------------------------------------------------------------------
  660.  
  661. proc doTextSize {textSize} {
  662.     if {[elec::Wrap "{\\$textSize " "}••"]} {
  663.         message "$textSize text set"
  664.     } else {
  665.         message "enter $textSize text"
  666.     }
  667. }
  668.  
  669. #--------------------------------------------------------------------------
  670. # ◊◊◊◊ Text Commands: ◊◊◊◊
  671. #--------------------------------------------------------------------------
  672.  
  673. proc textsuperscript {} {
  674.     if {[elec::Wrap "\\textsuperscript{" "}••"]} {
  675.         message "text superscripted"
  676.     } else {
  677.         message "enter superscripted text"
  678.     }
  679. }
  680. proc textcircled {} {
  681.     if {[elec::Wrap "\\textcircled{" "}••"]} {
  682.         message "text circled"
  683.     } else {
  684.         message "enter circled text"
  685.     }
  686. }
  687.  
  688. #--------------------------------------------------------------------------
  689. # ◊◊◊◊ International: ◊◊◊◊
  690. #--------------------------------------------------------------------------
  691.  
  692. proc {ò} {} {
  693.     if {[elec::Wrap "\\`{" "}••"]} {
  694.         message "accent set"
  695.     } else {
  696.         message "enter single character"
  697.     }
  698. }
  699. proc {ó} {} {
  700.     if {[elec::Wrap "\\'{" "}••"]} {
  701.         message "accent set"
  702.     } else {
  703.         message "enter single character"
  704.     }
  705. }
  706. proc {ô} {} {
  707.     if {[elec::Wrap "\\^{" "}••"]} {
  708.         message "accent set"
  709.     } else {
  710.         message "enter single character"
  711.     }
  712. }
  713. proc {ö} {} {
  714.     if {[elec::Wrap "\\\"{" "}••"]} {
  715.         message "accent set"
  716.     } else {
  717.         message "enter single character"
  718.     }
  719. }
  720. proc {õ} {} {
  721.     if {[elec::Wrap "\\~{" "}••"]} {
  722.         message "accent set"
  723.     } else {
  724.         message "enter single character"
  725.     }
  726. }
  727. proc {ç} {} {insertObject "\\c\{c\}"}
  728. proc {Ç} {} {insertObject "\\c\{C\}"}
  729. proc {œ} {} {insertObject "\\oe"}
  730. proc {Œ} {} {insertObject "\\OE"}
  731. proc {æ} {} {insertObject "\\ae"}
  732. proc {Æ} {} {insertObject "\\AE"}
  733. proc {å} {} {insertObject "\\aa"}
  734. proc {Å} {} {insertObject "\\AA"}
  735. proc {ø} {} {insertObject "\\o"}
  736. proc {Ø} {} {insertObject "\\O"}
  737. proc {ss} {} {insertObject "\\ss"}
  738. proc {SS} {} {insertObject "\\SS"}
  739. proc {¿} {} {insertObject "?`"}
  740. proc {¡} {} {insertObject "!`"}
  741.  
  742.  
  743. #--------------------------------------------------------------------------
  744. # ◊◊◊◊ Boxes: ◊◊◊◊
  745. #--------------------------------------------------------------------------
  746.  
  747. proc mbox {} {
  748.     if {[elec::Wrap "\\mbox{" "}••"]} {
  749.         message "mbox set"
  750.     } else {
  751.         message "enter text"
  752.     }
  753. }
  754. proc makebox {} {
  755.     if {[elec::Wrap "\\makebox\[••\]\[••\]{" "}••"]} {
  756.         message "makebox set; enter the width and position"
  757.     } else {
  758.         message "enter the width and position of the makebox, then the text"
  759.     }
  760. }
  761. proc fbox {} {
  762.     if {[elec::Wrap "\\fbox{" "}••"]} {
  763.         message "fbox set"
  764.     } else {
  765.         message "enter text"
  766.     }
  767. }
  768. proc framebox {} {
  769.     if {[elec::Wrap "\\framebox\[••\]\[••\]{" "}••"]} {
  770.         message "framebox set; enter the width and position"
  771.     } else {
  772.         message "enter the width and position of the framebox, then the text"
  773.     }
  774. }
  775. proc newsavebox {} {
  776.     if {[elec::Wrap "\\newsavebox{" "}••"]} {
  777.         message "newsavebox defined"
  778.     } else {
  779.         message "enter the command name of the sbox or savebox"
  780.     }
  781. }
  782. proc sbox {} {
  783.     if {[elec::Wrap "\\sbox{••}{" "}••"]} {
  784.         message "sbox set; enter the command name"
  785.     } else {
  786.         message "enter the command name of the sbox, then the text"
  787.     }
  788. }
  789. proc savebox {} {
  790.     if {[elec::Wrap "\\savebox{••}\[••\]\[••\]{" "}••"]} {
  791.         message "savebox set; enter the command name"
  792.     } else {
  793.         message "enter the command name of the savebox"
  794.     }
  795. }
  796. proc usebox {} {
  797.     if {[elec::Wrap "\\usebox{" "}••"]} {
  798.         message "usebox declared"
  799.     } else {
  800.         message "enter the command name of the sbox or savebox"
  801.     }
  802. }
  803. proc raisebox {} {
  804.     if {[elec::Wrap "\\raisebox{••}\[••\]\[••\]{" "}••"]} {
  805.         message "raisebox set; enter the displacement"
  806.     } else {
  807.         message "enter the displacement of the raisebox"
  808.     }
  809. }
  810. proc parbox {} {
  811.     if {[elec::Wrap "\\parbox\[••\]\{••\}{" "}••"]} {
  812.         message "parbox set; enter the position and width"
  813.     } else {
  814.         message "enter the position \[b|c|t\] and width of the parbox, then the text"
  815.     }
  816. }
  817. proc rule {} {
  818.     insertObject "\\rule\[••\]\{••\}{••}••"
  819.     message "enter the displacement of the rule, then width and height"
  820. }
  821.  
  822. #--------------------------------------------------------------------------
  823. # ◊◊◊◊ Misc: ◊◊◊◊
  824. #--------------------------------------------------------------------------
  825.  
  826. proc verb {} {
  827.     if {[elec::Wrap "\\verb|" "|••"]} {
  828.         message "verbatim text set"
  829.     } else {
  830.         message "enter verbatim text"
  831.     }
  832. }
  833. proc footnote {} {
  834.     if {[elec::Wrap "\\footnote{" "}••"]} {
  835.         message "footnote set"
  836.     } else {
  837.         message "enter footnote"
  838.     }
  839. }
  840. proc marginalNote {} {
  841.     if {[elec::Wrap "\\marginpar{" "}••"]} {
  842.         message "marginal note set"
  843.     } else {
  844.         message "enter marginal note"
  845.     }
  846. }
  847.  
  848. proc insertLabel {} {
  849.     if {[elec::Wrap "\\label{" "}••"]} {
  850.         message "label defined"
  851.     } else {
  852.         message "enter label"
  853.     }
  854. }
  855. proc ref {} { 
  856.     global completion::in_progress_pos
  857.     if {[pos::compare [set completion::in_progress_pos] == [getPos]]} {
  858.     bind::Completion
  859.     } else {
  860.     if {[elec::Wrap "\\ref{" "}••" 1]} {
  861.         message "reference made"
  862.     } else {
  863.         message "enter reference label"
  864.     }
  865.     }
  866. }
  867. proc eqref {} { 
  868.     global completion::in_progress_pos standardTeXLabelDelimiter
  869.     if {[pos::compare [set completion::in_progress_pos] == [getPos]]} {
  870.     bind::Completion
  871.     } else {
  872.     if {[elec::Wrap "\\eqref\{eq${standardTeXLabelDelimiter}" "\}••" 1]} {
  873.         message "reference made"
  874.     } else {
  875.         message "enter reference label"
  876.     }
  877.     }
  878. }
  879. proc pageref {} { 
  880.     global completion::in_progress_pos
  881.     if {[pos::compare [set completion::in_progress_pos] == [getPos]]} {
  882.     bind::Completion
  883.     } else {
  884.     if {[elec::Wrap "\\pageref{" "}••" 1]} {
  885.         message "page reference made"
  886.     } else {
  887.         message "enter page reference label"
  888.     }
  889.     }
  890. }
  891. proc cite {} {
  892.     if {[elec::Wrap "\\cite{" "}••" 1]} {
  893.         message "citation made"
  894.     } else {
  895.         message "enter citation key"
  896.     }
  897. }
  898. proc nocite {} {
  899.     if {[elec::Wrap "\\nocite{" "}••"]} {
  900.         message "citation added to the list"
  901.     } else {
  902.         message "enter citation key"
  903.     }
  904. }
  905.  
  906. # Insert an \item or a \bibitem, depending on the context.
  907. proc insertItem {} {
  908.     set command [eval getText [searchEnvironment]]
  909.     set environment [extractCommandArg $command]
  910.     switch $environment {
  911.         "itemize" {
  912.             set text "\\item  ••"
  913.         }
  914.         "enumerate" {
  915.             set text "\\item  ••"
  916.         }
  917.         "description" {
  918.             set text "\\item\[••\]  ••"
  919.         }
  920.         "thebibliography" {
  921.             set text "\\bibitem{••}  ••"
  922.         }
  923.         default {
  924.             beep
  925.             message "insertItem: cursor in $environment environment"
  926.             return
  927.         }
  928.     }
  929.     set pos [getPos]
  930.     # Indentation should mirror that of an existing \item
  931.     # (if it exists)
  932.     elec::Insertion [openingCarriageReturn]$text
  933. }
  934.  
  935. proc quotes {} {
  936.     if {[elec::Wrap "`" "'••"]} {
  937.         message "text quoted"
  938.     } else {
  939.         message "enter text"
  940.     }
  941. }
  942. proc dblQuotes {} {
  943.     if {[elec::Wrap "``" "''••"]} {
  944.         message "text double quoted"
  945.     } else {
  946.         message "enter text"
  947.     }
  948. }
  949.  
  950. proc texLogo {} {insertObject "\\TeX"}
  951. proc latexLogo {} {insertObject "\\LaTeX"}
  952. proc latex2eLogo {} {insertObject "\\LaTeXe"}
  953. proc today {} {insertObject "\\today"}
  954.  
  955. proc dag {} {insertObject "\\dag"}
  956. proc ddag {} {insertObject "\\ddag"}
  957. proc sectionMark {} {insertObject "\\S"}
  958. proc paragraphMark {} {insertObject "\\P"}
  959. proc copyright {} {insertObject "\\copyright"}
  960. proc pounds {} {insertObject "\\pounds"}
  961.  
  962.  
  963. #############################################################################
  964. # 
  965. # Math Mode Macros
  966. #
  967. #############################################################################
  968.  
  969. #--------------------------------------------------------------------------
  970. # ◊◊◊◊ Math Modes: ◊◊◊◊
  971. #--------------------------------------------------------------------------
  972.  
  973. proc texMath {} {
  974.     checkMathMode "texMath" 0
  975.     if {[elec::Wrap "$" "$••"]} {
  976.         message "formula set"
  977.     } else {
  978.         message "enter formula"
  979.     }
  980. }
  981. proc texDisplaymath {} {
  982.     checkMathMode "texDisplaymath" 0
  983.     if {[elec::Wrap "$$" "$$••"]} {
  984.         message "displayed formula set"
  985.     } else {
  986.         message "enter displayed formula"
  987.     }
  988. }
  989. proc latexMath {} {
  990.     checkMathMode "latexMath" 0
  991.     if {[elec::Wrap "\\( " " \\)••"]} {
  992.         message "formula set"
  993.     } else {
  994.         message "enter formula"
  995.     }
  996. }
  997. proc latexDisplaymath {} {
  998.     checkMathMode "latexDisplaymath" 0
  999.     if {[elec::Wrap "\\\[ " " \\\]••"]} {
  1000.         message "displayed formula set"
  1001.     } else {
  1002.         message "enter displayed formula"
  1003.     }
  1004. }
  1005.  
  1006. #--------------------------------------------------------------------------
  1007. # ◊◊◊◊ Math Style: ◊◊◊◊
  1008. #--------------------------------------------------------------------------
  1009.  
  1010. proc doMathStyle {mathStyle description} {
  1011.     checkMathMode "$mathStyle" 1
  1012.     if {[elec::Wrap "\\$mathStyle{" "}••"]} {
  1013.         message "selected text is $description"
  1014.     } else {
  1015.         message "enter text to be $description"
  1016.     }
  1017. }
  1018. proc doUppercaseMathStyle {mathStyle description} {
  1019.     checkMathMode "$mathStyle" 1
  1020.     # Allow upper-case alphabetic arguments only:
  1021.     if {[isSelection] && (![isUppercase] || ![isAlphabetic])} {
  1022.         beep
  1023.         alertnote "argument to \\$mathStyle must be UPPERCASE alphabetic"
  1024.         return
  1025.     }
  1026.     if {[elec::Wrap "\\$mathStyle{" "}••"]} {
  1027.         message "selected text is $description"
  1028.     } else {
  1029.         message "enter text to be $description (UPPERCASE letters only)"
  1030.     }
  1031. }
  1032.  
  1033.  
  1034. #--------------------------------------------------------------------------
  1035. # ◊◊◊◊ Formulas: ◊◊◊◊
  1036. #--------------------------------------------------------------------------
  1037.  
  1038. proc subscript {} {
  1039.     checkMathMode "subscript" 1
  1040.     if {[elec::Wrap "_{" "}••"]} {
  1041.         message "subscript set"
  1042.     } else {
  1043.         message "enter subscript"
  1044.     }
  1045. }
  1046. proc superscript {} {
  1047.     checkMathMode "superscript" 1
  1048.     if {[elec::Wrap "^{" "}••"]} {
  1049.         message "superscript set"
  1050.     } else {
  1051.         message "enter superscript"
  1052.     }
  1053. }
  1054. proc fraction {} {
  1055.     checkMathMode "fraction" 1
  1056.     set currentPos [getPos]
  1057.     if {[isSelection]} {
  1058.         set selection [getSelect]
  1059.         set args [split $selection /]
  1060.         set len [llength $args]
  1061.         deleteText $currentPos [selEnd]
  1062.         if {$len == 1} {
  1063.             insertObject "\\frac{$selection}{••}••"
  1064.             message "enter denominator"
  1065.         } else {
  1066.             set firstArg [lindex $args 0]
  1067.             set restArgs [lrange $args 1 [expr $len-1]]
  1068.             insertObject "\\frac{$firstArg}{[join $restArgs /]}"
  1069.             if {$len > 2} {message "beware of multiple /"}
  1070.         }
  1071.     } else {
  1072.         insertObject "\\frac{••}{••}••"
  1073.         message "enter numerator"
  1074.     }
  1075. }
  1076. proc squareRoot {} {
  1077.     checkMathMode "squareRoot" 1
  1078.     if {[elec::Wrap "\\sqrt{" "}••"]} {
  1079.         message "square root set"
  1080.     } else {
  1081.         message "enter formula"
  1082.     }
  1083. }
  1084. proc nthRoot {} {
  1085.     checkMathMode "nthRoot" 1
  1086.     if {[elec::Wrap "\\sqrt\[••\]{" "}••"]} {
  1087.         message "enter root"
  1088.     } else {
  1089.         message "enter root, then formula"
  1090.     }
  1091. }
  1092. proc oneParameter {} {
  1093.     checkMathMode "oneParameter" 1
  1094.     if {[elec::Wrap "\\••{" "}••"]} {
  1095.         message "enter command name"
  1096.     } else {
  1097.         message "enter command name, press <Tab>, enter argument"
  1098.     }
  1099. }
  1100. proc twoParameters {} {
  1101.     checkMathMode "twoParameters" 1
  1102.     if {[elec::Wrap "\\••{" "}{••}••"]} {
  1103.         message "enter command name"
  1104.     } else {
  1105.         message "enter command name, press <Tab>, enter argument, etc."
  1106.     }
  1107. }
  1108.  
  1109. #--------------------------------------------------------------------------
  1110. # ◊◊◊◊ Large Ops: ◊◊◊◊
  1111. #--------------------------------------------------------------------------
  1112.  
  1113. proc insertLargeOp {commandName} {
  1114.     checkMathMode "$commandName" 1
  1115.     insertObject "\\$commandName\_{••}^{••}••"
  1116. }
  1117. proc sum {} {insertLargeOp "sum"}
  1118. proc prod {} {insertLargeOp "prod"}
  1119. proc coprod {} {insertLargeOp "coprod"}
  1120. proc int {} {insertLargeOp "int"}
  1121. proc oint {} {insertLargeOp "oint"}
  1122. proc bigcap {} {insertLargeOp "bigcap"}
  1123. proc bigcup {} {insertLargeOp "bigcup"}
  1124. proc bigsqcup {} {insertLargeOp "bigsqcup"}
  1125. proc bigvee {} {insertLargeOp "bigvee"}
  1126. proc bigwedge {} {insertLargeOp "bigwedge"}
  1127. proc bigodot {} {insertLargeOp "bigodot"}
  1128. proc bigotimes {} {insertLargeOp "bigotimes"}
  1129. proc bigoplus {} {insertLargeOp "bigoplus"}
  1130. proc biguplus {} {insertLargeOp "biguplus"}
  1131.  
  1132. #--------------------------------------------------------------------------
  1133. # ◊◊◊◊ Delimiters: ◊◊◊◊
  1134. #--------------------------------------------------------------------------
  1135.  
  1136. proc delimitObject {leftDelim rightDelim} {
  1137.     if {[elec::Wrap $leftDelim $rightDelim]} {
  1138.         message "formula delimited"
  1139.     } else {
  1140.         message "enter formula"
  1141.     }
  1142. }
  1143. proc parentheses {} { checkMathMode "parentheses" 1; delimitObject "(" ")••" }
  1144. proc brackets {} { checkMathMode "brackets" 1; delimitObject "\[" "\]••" }
  1145. proc braces {} { checkMathMode "braces" 1; delimitObject "\\\{" "\\\}••" }
  1146. proc absoluteValue {} { checkMathMode "absoluteValue" 1; delimitObject "|" "|••" }
  1147. proc getDelims {} {
  1148.     catch {prompt "Choose delimiters:" "parentheses" "" "parentheses" \
  1149.                   "brackets" "braces" "angle brackets" "vertical bars" \
  1150.                   "double bars" "ceiling" "floor"} delimType
  1151.     if {$delimType != "cancel"} {
  1152.         switch $delimType {
  1153.             "parentheses" {
  1154.                 set leftDelim "("
  1155.                 set rightDelim ")"
  1156.             }
  1157.             "brackets" {
  1158.                 set leftDelim "\["
  1159.                 set rightDelim "\]"
  1160.             }
  1161.             "braces" {
  1162.                 set leftDelim "\\\{"
  1163.                 set rightDelim "\\\}"
  1164.             }
  1165.             "vertical bars" {
  1166.                 set leftDelim "|"
  1167.                 set rightDelim "|"
  1168.             }
  1169.             "double bars" {
  1170.                 set leftDelim "\\|"
  1171.                 set rightDelim "\\|"
  1172.             }
  1173.             "angle brackets" {
  1174.                 set leftDelim "\\langle"
  1175.                 set rightDelim "\\rangle"
  1176.             }
  1177.             "ceiling" {
  1178.                 set leftDelim "\\lceil"
  1179.                 set rightDelim "\\rceil"
  1180.             }
  1181.             "floor" {
  1182.                 set leftDelim "\\lfloor"
  1183.                 set rightDelim "\\rfloor"
  1184.             }
  1185.             default {
  1186.                 alertnote "\"$delimType\" not recognized"
  1187.                 return ""
  1188.             }
  1189.         }
  1190.         return [list $leftDelim $rightDelim]
  1191.     } else {return ""}
  1192. }
  1193. proc otherDelims {} {
  1194.     checkMathMode "otherDelims" 1
  1195.     set delims [getDelims]
  1196.     if {$delims != ""} {
  1197.         set leftDelim [lindex $delims 0]
  1198.         set rightDelim [lindex $delims 1]
  1199.         delimitObject "$leftDelim" "$rightDelim••"
  1200.     }
  1201. }
  1202. proc {half-openInterval} {} {
  1203.     checkMathMode "half-openInterval" 1; delimitObject "(" "\]••"
  1204. }
  1205. proc {half-closedInterval} {} {
  1206.     checkMathMode "half-closedInterval" 1; delimitObject "\[" ")••"
  1207. }
  1208. proc insertBigDelims {leftDelim rightDelim isMultiline} {
  1209.     checkMathMode "insertBigDelims" 1
  1210.     if {$isMultiline} {
  1211.         doWrapStructure $leftDelim "" $rightDelim
  1212.     } else {
  1213.         if { [elec::Wrap $leftDelim $rightDelim] } {
  1214.             message "formula delimited"
  1215.         } else {
  1216.             message "enter formula"
  1217.         }
  1218.     }
  1219. }
  1220. proc bigParens {} {
  1221.     checkMathMode "bigParens" 1; insertBigDelims "\\left(" "\\right)••" 0
  1222. }
  1223. proc multiBigParens {} {
  1224.     checkMathMode "multiBigParens" 1; insertBigDelims "\\left(" "\\right)••" 1
  1225. }
  1226. proc bigBrackets {} {
  1227.     checkMathMode "bigBrackets" 1; insertBigDelims "\\left\[" "\\right\]••" 0
  1228. }
  1229. proc multiBigBrackets {} {
  1230.     checkMathMode "multiBigBrackets" 1; insertBigDelims "\\left\[" "\\right\]••" 1
  1231. }
  1232. proc bigBraces {} {
  1233.     checkMathMode "bigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}••" 0
  1234. }
  1235. proc multiBigBraces {} {
  1236.     checkMathMode "multiBigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}••" 1
  1237. }
  1238. proc bigAbsValue {} {
  1239.     checkMathMode "bigAbsValue" 1; insertBigDelims "\\left|" "\\right|••" 0
  1240. }
  1241. proc multiBigAbsValue {} {
  1242.     checkMathMode "multiBigAbsValue" 1; insertBigDelims "\\left|" "\\right|••" 1
  1243. }
  1244. proc doOtherBigDelims {name isMultiline} {
  1245.     checkMathMode $name 1
  1246.     set delims [getDelims]
  1247.     if {$delims != ""} {
  1248.         append leftDelim "\\left" [lindex $delims 0]
  1249.         append rightDelim "\\right" [lindex $delims 1]
  1250.         insertBigDelims "$leftDelim" "$rightDelim••" $isMultiline
  1251.     }
  1252. }
  1253. proc otherBigDelims {} {
  1254.     doOtherBigDelims "otherBigDelims" 0
  1255. }
  1256. proc otherMultiBigDelims {} {
  1257.     doOtherBigDelims "otherMultiBigDelims" 1
  1258. }
  1259. proc bigLeftBrace {} {
  1260.     checkMathMode "bigLeftBrace" 1
  1261.     insertBigDelims "\\left\\\{" "\\right.••" 0
  1262. }
  1263. proc multiBigLeftBrace {} {
  1264.     checkMathMode "multiBigLeftBrace" 1
  1265.     insertBigDelims "\\left\\\{" "\\right.••" 1
  1266. }
  1267. proc doOtherMixedBigDelims {name isMultiline} {
  1268.     checkMathMode $name 1
  1269.     catch {prompt "Choose LEFT delimiter:" "parenthesis" "" "parenthesis" \
  1270.                   "bracket" "brace" "vertical bar" "double bar" \
  1271.                   "angle bracket" "ceiling" "floor" "slash" "backslash" \
  1272.                   "none"} delimType
  1273.     if {$delimType != "cancel"} {
  1274.         switch $delimType {
  1275.             "parenthesis" {set leftDelim "("}
  1276.             "bracket" {set leftDelim "\["}
  1277.             "brace" {set leftDelim "\\\{"}
  1278.             "vertical bar" {set leftDelim "|"}
  1279.             "double bar" {set leftDelim "\\|"}
  1280.             "angle bracket" {set leftDelim "\\langle"}
  1281.             "ceiling" {set leftDelim "\\lceil"}
  1282.             "floor" {set leftDelim "\\lfloor"}
  1283.             "slash" {set leftDelim "/"}
  1284.             "backslash" {set leftDelim "\\backslash"}
  1285.             "none" {set leftDelim "."}
  1286.             default {
  1287.                 alertnote "\"$delimType\" not recognized"
  1288.                 return
  1289.             }
  1290.         }
  1291.         catch {prompt "Choose RIGHT delimiter:" "parenthesis" "" "parenthesis" \
  1292.                       "bracket" "brace" "vertical bar" "double bar" \
  1293.                       "angle bracket" "ceiling" "floor" "slash" "backslash" \
  1294.                       "none"} delimType
  1295.         if {$delimType != "cancel"} {
  1296.             switch $delimType {
  1297.                 "parenthesis" {set rightDelim ")"}
  1298.                 "bracket" {set rightDelim "\]"}
  1299.                 "brace" {set rightDelim "\\\}"}
  1300.                 "vertical bar" {set rightDelim "|"}
  1301.                 "double bar" {set rightDelim "\\|"}
  1302.                 "angle bracket" {set rightDelim "\\rangle"}
  1303.                 "ceiling" {set rightDelim "\\rceil"}
  1304.                 "floor" {set rightDelim "\\rfloor"}
  1305.                 "slash" {set rightDelim "/"}
  1306.                 "backslash" {set rightDelim "\\backslash"}
  1307.                 "none" {set rightDelim "."}
  1308.                 default {
  1309.                     alertnote "\"$delimType\" not recognized"
  1310.                     return
  1311.                 }
  1312.             }
  1313.             insertBigDelims "\\left$leftDelim" "\\right$rightDelim••" $isMultiline
  1314.         }
  1315.     }
  1316. }
  1317. proc otherMixedBigDelims {} {
  1318.     doOtherMixedBigDelims "otherMixedBigDelims" 0
  1319. }
  1320. proc otherMultiMixedBigDelims {} {
  1321.     doOtherMixedBigDelims "otherMultiMixedBigDelims" 1
  1322. }
  1323. #--------------------------------------------------------------------------
  1324. # ◊◊◊◊ Accents: ◊◊◊◊
  1325. #--------------------------------------------------------------------------
  1326. proc acute {} {
  1327.     checkMathMode "acute" 1
  1328.     if {[isSelection] > 1} {
  1329.         alertnote "Warning: only a single character may be accented!"
  1330.     }
  1331.     if {[elec::Wrap "\\acute{" "}••"]} {
  1332.         message "accent set"
  1333.     } else {
  1334.         message "enter one character"
  1335.     }
  1336. }
  1337. proc bar {} {
  1338.     checkMathMode "bar" 1
  1339.     if {[isSelection] > 1} {
  1340.         alertnote "Warning: only a single character may be accented!"
  1341.     }
  1342.     if {[elec::Wrap "\\bar{" "}••"]} {
  1343.         message "accent set"
  1344.     } else {
  1345.         message "enter one character"
  1346.     }
  1347. }
  1348. proc breve {} {
  1349.     checkMathMode "breve" 1
  1350.     if {[isSelection] > 1} {
  1351.         alertnote "Warning: only a single character may be accented!"
  1352.     }
  1353.     if {[elec::Wrap "\\breve{" "}••"]} {
  1354.         message "accent set"
  1355.     } else {
  1356.         message "enter one character"
  1357.     }
  1358. }
  1359. proc check {} {
  1360.     checkMathMode "check" 1
  1361.     if {[isSelection] > 1} {
  1362.         alertnote "Warning: only a single character may be accented!"
  1363.     }
  1364.     if {[elec::Wrap "\\check{" "}••"]} {
  1365.         message "accent set"
  1366.     } else {
  1367.         message "enter one character"
  1368.     }
  1369. }
  1370. proc dot {} {
  1371.     checkMathMode "dot" 1
  1372.     if {[isSelection] > 1} {
  1373.         alertnote "Warning: only a single character may be accented!"
  1374.     }
  1375.     if {[elec::Wrap "\\dot{" "}••"]} {
  1376.         message "accent set"
  1377.     } else {
  1378.         message "enter one character"
  1379.     }
  1380. }
  1381. proc ddot {} {
  1382.     checkMathMode "ddot" 1
  1383.     if {[isSelection] > 1} {
  1384.         alertnote "Warning: only a single character may be accented!"
  1385.     }
  1386.     if {[elec::Wrap "\\ddot{" "}••"]} {
  1387.         message "accent set"
  1388.     } else {
  1389.         message "enter one character"
  1390.     }
  1391. }
  1392. proc grave {} {
  1393.     checkMathMode "grave" 1
  1394.     if {[isSelection] > 1} {
  1395.         alertnote "Warning: only a single character may be accented!"
  1396.     }
  1397.     if {[elec::Wrap "\\grave{" "}••"]} {
  1398.         message "accent set"
  1399.     } else {
  1400.         message "enter one character"
  1401.     }
  1402. }
  1403. proc hat {} {
  1404.     checkMathMode "hat" 1
  1405.     if {[isSelection] > 1} {
  1406.         alertnote "Warning: only a single character may be accented!"
  1407.     }
  1408.     if {[elec::Wrap "\\hat{" "}••"]} {
  1409.         message "accent set"
  1410.     } else {
  1411.         message "enter one character"
  1412.     }
  1413. }
  1414. proc tilde {} {
  1415.     checkMathMode "tilde" 1
  1416.     if {[isSelection] > 1} {
  1417.         alertnote "Warning: only a single character may be accented!"
  1418.     }
  1419.     if {[elec::Wrap "\\tilde{" "}••"]} {
  1420.         message "accent set"
  1421.     } else {
  1422.         message "enter one character"
  1423.     }
  1424. }
  1425. proc vec {} {
  1426.     checkMathMode "vec" 1
  1427.     if {[isSelection] > 1} {
  1428.         alertnote "Warning: only a single character may be accented!"
  1429.     }
  1430.     if {[elec::Wrap "\\vec{" "}••"]} {
  1431.         message "accent set"
  1432.     } else {
  1433.         message "enter one character"
  1434.     }
  1435. }
  1436. proc widehat {} {
  1437.     checkMathMode "widehat" 1
  1438.     if {[isSelection] > 3} {
  1439.         alertnote "Warning: only a few characters may be accented!"
  1440.     }
  1441.     if {[elec::Wrap "\\widehat{" "}••"]} {
  1442.         message "accent set"
  1443.     } else {
  1444.         message "enter a few characters"
  1445.     }
  1446. }
  1447. proc widetilde {} {
  1448.     checkMathMode "widetilde" 1
  1449.     if {[isSelection] > 3} {
  1450.         alertnote "Warning: only a few characters may be accented!"
  1451.     }
  1452.     if {[elec::Wrap "\\widetilde{" "}••"]} {
  1453.         message "accent set"
  1454.     } else {
  1455.         message "enter a few characters"
  1456.     }
  1457. }
  1458.  
  1459. #--------------------------------------------------------------------------
  1460. # ◊◊◊◊ Grouping: ◊◊◊◊
  1461. #--------------------------------------------------------------------------
  1462. proc underline {} {
  1463.     checkMathMode "underline" 1
  1464.     if {[elec::Wrap "\\underline{" "}••"]} {
  1465.         message "selection underlined"
  1466.     } else {
  1467.         message "enter text"
  1468.     }
  1469. }
  1470. proc overline {} {
  1471.     checkMathMode "overline" 1
  1472.     if {[elec::Wrap "\\overline{" "}••"]} {
  1473.         message "selection overlined"
  1474.     } else {
  1475.         message "enter text"
  1476.     }
  1477. }
  1478. proc underbrace {} {
  1479.     checkMathMode "underbrace" 1
  1480.     if {[elec::Wrap "\\underbrace{" "}••"]} {
  1481.         message "selection underbraced"
  1482.     } else {
  1483.         message "enter text"
  1484.     }
  1485. }
  1486. proc overbrace {} {
  1487.     checkMathMode "overbrace" 1
  1488.     if {[elec::Wrap "\\overbrace{" "}••"]} {
  1489.         message "selection overbraced"
  1490.     } else {
  1491.         message "enter text"
  1492.     }
  1493. }
  1494. proc overrightarrow {} {
  1495.     checkMathMode "overrightarrow" 1
  1496.     if {[elec::Wrap "\\overrightarrow{" "}••"]} {
  1497.         message "selection overrightarrowed"
  1498.     } else {
  1499.         message "enter text"
  1500.     }
  1501. }
  1502. proc overleftarrow {} {
  1503.     checkMathMode "overleftarrow" 1
  1504.     if {[elec::Wrap "\\overleftarrow{" "}••"]} {
  1505.         message "selection overleftarrowed"
  1506.     } else {
  1507.         message "enter text"
  1508.     }
  1509. }
  1510. proc stackrel {} {
  1511.     checkMathMode "stackrel" 1
  1512.     set currentPos [getPos]
  1513.     if {[insertObject "\\stackrel{••}{••}••"]} {
  1514.         message "1st arg scriptstyle"
  1515.     }
  1516. }
  1517. #--------------------------------------------------------------------------
  1518. # ◊◊◊◊ Spacing: ◊◊◊◊
  1519. #--------------------------------------------------------------------------
  1520. proc negThin {} {checkMathMode "negThin" 1; insertObject "\\!"}
  1521. proc thin {} {checkMathMode "thin" 1; insertObject "\\,"}
  1522. proc medium {} {checkMathMode "medium" 1; insertObject "\\:"}
  1523. proc thick {} {checkMathMode "thick" 1; insertObject "\\;"}
  1524. proc quad {} {checkMathMode "quad" 1; insertObject "\\quad"}
  1525. proc qquad {} {checkMathMode "qquad" 1; insertObject "\\qquad"}
  1526. proc hspace {} {
  1527.     checkMathMode "hspace" 1
  1528.     if {[elec::Wrap "\\hspace{" "}••"]} {
  1529.         message "spacing set"
  1530.     } else {
  1531.         message "enter the desired horizontal spacing"
  1532.     }
  1533. }
  1534. proc vspace {} {
  1535.     checkMathMode "vspace" 1
  1536.     if {[elec::Wrap "\\vspace{" "}••"]} {
  1537.         message "spacing set"
  1538.     } else {
  1539.         message "enter the desired horizontal spacing"
  1540.     }
  1541. }
  1542. proc hfill {} {checkMathMode "hfill" 1; insertObject "\\hfill"}
  1543. proc vfill {} {checkMathMode "vfill" 1; insertObject "\\vfill"}
  1544. proc smallskip {} {checkMathMode "smallskip" 1; insertObject "\\smallskip"}
  1545. proc medskip {} {checkMathMode "medskip" 1; insertObject "\\medskip"}
  1546. proc bigskip {} {checkMathMode "bigskip" 1; insertObject "\\bigskip"}
  1547.